package com.dkm.ec.sale.repository.impl;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.springframework.stereotype.Repository;

import com.dkm.base.api.annotion.SKGCacheable;
import com.dkm.base.api.constants.RedisConstants;
import com.dkm.base.api.model.Page;
import com.dkm.base.core.helper.SpringHelper;
import com.dkm.base.core.util.string.StringUtils;
import com.dkm.base.db.persistence.dao.IQueryDao;
import com.dkm.biz.repository.AbstractRepository;
import com.dkm.ec.product.persistence.entity.ProductMediaPo;
import com.dkm.ec.product.repository.ProductMediaRepository;
import com.dkm.ec.sale.domain.SaleConstants;
import com.dkm.ec.sale.domain.SaleSku;
import com.dkm.ec.sale.persistence.dao.SaleSkuQueryDao;
import com.dkm.ec.sale.persistence.entity.SalePackageItemPo;
import com.dkm.ec.sale.persistence.entity.SaleSkuPo;
import com.dkm.ec.sale.repository.SalePackageItemRepository;
import com.dkm.ec.sale.repository.SaleSkuRepository;

/**
 * 对象功能:销售产品SKU Repository接口的实现类
 * 开发公司:SKG.COM
 * 开发人员:Yuki
 * 创建时间:2015-01-22 13:52:18
 */
@Repository
public class SaleSkuRepositoryImpl extends AbstractRepository<String, SaleSkuPo,SaleSku> implements SaleSkuRepository{
	  
	@Resource
	private  SaleSkuQueryDao saleSkuQueryDao;
	@Resource
	private SalePackageItemRepository salePackageItemRepository;
	@Resource
	private ProductMediaRepository productMediaRepository;
/*	@Resource
	private StockRepository stockRepository;*/

	public SaleSku newInstance() {
		SaleSkuPo po = new SaleSkuPo();
		SaleSku saleSku = SpringHelper.getBean(SaleSku.class);
		saleSku.setData(po);
		return saleSku;
	}

	public SaleSku newInstance(SaleSkuPo po) {
		SaleSku saleSku = SpringHelper.getBean(SaleSku.class);
		saleSku.setData(po);
		return saleSku;
	} 
	
	@Override
	protected IQueryDao<String, SaleSkuPo> getQueryDao() {
		return saleSkuQueryDao;
	}

	@Override
	public List<SaleSkuPo> findByProdId(String prodId) {
		return saleSkuQueryDao.findByProdId(prodId);
	}
	
	
	@Override
	public List<SaleSkuPo> findByProdId2(Map<String, Object> params) {
		return saleSkuQueryDao.findByProdId2(params);	
	}	

	@Override
	public List<SaleSkuPo> findByProdIdAttrIds(String prodId, String attrIds) {
		return saleSkuQueryDao.findByProdIdAttrIds(prodId,attrIds);
	}

	@Override
	public SaleSkuPo getDefaultSkuId(String prodId) {
		return saleSkuQueryDao.getDefaultSkuId(prodId);
	}

	@Override
	public List<SaleSkuPo> findForSelectorPaged(Map<String, Object> map,
			Page page) {
		return saleSkuQueryDao.findByKey("findForSelect", map,page);
	}

	@Override
	public Integer countForSelector(Map<String, Object> params) {
		return saleSkuQueryDao.countByKey("countForSelect", params);
	}

	@Override
	public List<SaleSkuPo> findSaleSku(String userId, String productSkuId,
			Integer count) {
		// TODO Auto-generated method stub
		return this.saleSkuQueryDao.findSaleSku(userId,productSkuId,count);
	}

	/* (non-Javadoc)
	 * @see com.skg.ec.sale.repository.SaleSkuRepository#listSkuMsg(java.util.Map, com.skg.base.api.model.Page)
	 */
	@Override
	public List<SaleSkuPo> listSkuMsg(Map<String, Object> buildMap, Page page) {
		return saleSkuQueryDao.findByKey("listSkuMsg", buildMap, page);
	}

	@Override
	public List<SaleSkuPo> findOnSaleSkuByProdId(String productId) {
		List<SaleSkuPo> results = new ArrayList<SaleSkuPo>();
		List<SaleSkuPo> saleSkuPos = saleSkuQueryDao.findByProdId(productId);
		for(SaleSkuPo saleSkuPo:saleSkuPos){
			if(saleSkuPo.getStatus().equals("on_sale")){
				results.add(saleSkuPo);
			}
		}
		return results;
	}

	@Override
	public List<SaleSkuPo> findByKeyAndStatus(String key, String status) {
		Map<String, Object> parmsMap = new HashMap<String, Object>();
		parmsMap.put("key", key);
		parmsMap.put("status", status);
		return saleSkuQueryDao.findByKey("findByKeyAndStatus", parmsMap);
	}

	//TODO 这样实现性能并不好，以后在购物车项目和订单项目表加 产品ID字段。
	@SKGCacheable(db=RedisConstants.PRODUCT,key="checkSameProd_${skuId1}_${skuId2}",params="skuId1,skuId2",seconds=60000)
	public Boolean checkSameProd(String skuId1, String skuId2) {
		Boolean isSame = false;
		Integer checkNum = saleSkuQueryDao.checkSameProd(skuId1, skuId2);
		if(checkNum!=null && checkNum.intValue()==1) isSame= true;
		else isSame=false;
		return isSame;
	}

	@Override
	public List<SaleSkuPo> findBySkuIds(String skuIds) {
		List<SaleSkuPo> saleSkuPos = new ArrayList<SaleSkuPo>();
		String[] skuIdArr = skuIds.split(",");
		for(int i=0; i<skuIdArr.length; i++){
			SaleSkuPo saleSkuPo = saleSkuQueryDao.get(skuIdArr[i]);
			saleSkuPos.add(saleSkuPo);
		}
		return saleSkuPos;
	}
	
	@Override
	public List<SaleSkuPo> findByGroupKey(String group,Page page){
		return saleSkuQueryDao.findByGroupKey(group,page);
	}

	@Override
	public Integer getCountbyGroupKey(String group) {
		return saleSkuQueryDao.getCountbyGroupKey(group);
	}

	@Override
	public SaleSkuPo getSaleSkuPoByKey(String key) {
		Map<String, Object> params=new HashMap<String, Object>();
		params.put("key", key);
		return saleSkuQueryDao.getByKey("getSaleSkuPoByKey", params);
	}
	
	@Override
	public SaleSkuPo getBySkuCode(String skuCode){
		return saleSkuQueryDao.getBySkuCode(skuCode);
	}

	
	@Override
	public List<SaleSkuPo> findSkuByIds(List<String> groupIds) {
		return saleSkuQueryDao.findSkuByIds(groupIds);
	}

	@Override
	public List<SaleSkuPo> findSaleTypeNotStock() {
		Map<String, Object> params = new HashMap<String, Object>();
		return saleSkuQueryDao.findByKey("findSaleTypeNotStock", params);
	}

	@Override
	public List<SaleSkuPo> findPackageByItemSku(String itemSkuId, String callType) {
		List<SaleSkuPo> saleSkuPos = new ArrayList<SaleSkuPo>();
		List<SalePackageItemPo> salePackageItemPos = salePackageItemRepository.findByItemSku(itemSkuId);
		for(SalePackageItemPo salePackageItemPo : salePackageItemPos){
			SaleSku saleSku  = this.load(salePackageItemPo.getSkuId());
			if(saleSku != null){
				if(!SaleConstants.SKU_STATUS.ON_SALE.equals(saleSku.getData().getStatus())){
					continue;
				}
				// 查询对应渠道库存
				/*Stock stock = stockRepository.newInstance();
				Integer qtyStock = stock.queryStock(saleSku.getData().getId(), callType);
				saleSku.getData().setMaxTotal(qtyStock);
				if (qtyStock <= 0)
					continue;
					//saleSku.getData().setStatus("sold_out");
				if (1 <= qtyStock && qtyStock <= StockStatus.STOCK_INTEGER) {
					saleSku.getData().setStockStatus(StockStatus.STOCK_STRING);
				}
				List<SaleSkuPo> packageItemSaleSkuPos = this.findPackageItemsBySkuId(saleSku.getData());
				
				boolean flag = true;
				for(SaleSkuPo saleSkuPo : packageItemSaleSkuPos){
					if(!SaleConstants.SKU_STATUS.ON_SALE.equals(saleSkuPo.getStatus())){
						flag = false;
						continue;
					}
				}
				if(!flag){
					continue;
				}*/
				
		//		saleSku.getData().setPackageSaleSkuPos(packageItemSaleSkuPos);
				saleSkuPos.add(saleSku.getData());
			}
		}
		return saleSkuPos;
	}
	
	/**
	 * 平摊 产品包 中商品的价格
	 * @param packageSaleSkuPo
	 * @return
	 */
	public void handlePackagePrice(SaleSkuPo packageSaleSkuPo, List<SaleSkuPo> saleSkuPos){
		BigDecimal packagePrice = new BigDecimal(packageSaleSkuPo.getSalesPrice());
		
		BigDecimal originalPrice = BigDecimal.ZERO;		//产品包原价（包内所有产品的销售价总和）
		BigDecimal salePercent = BigDecimal.ZERO;		//产品包销售价/产品包原价
		BigDecimal salePriceTmp = BigDecimal.ZERO;		//无任何意义，只为了计算平摊价的中间参数
		for(SaleSkuPo saleSkuPo : saleSkuPos){
			originalPrice = originalPrice.add(new BigDecimal(saleSkuPo.getSalesPrice()));
		}
		if(originalPrice.compareTo(new BigDecimal(packageSaleSkuPo.getSalesPrice())) > 0){
			packageSaleSkuPo.setDiscountAmount(originalPrice.subtract(new BigDecimal(packageSaleSkuPo.getSalesPrice())));
		}
		if(originalPrice.compareTo(BigDecimal.ZERO) > 0){
			salePercent = packagePrice.divide(originalPrice, 4, BigDecimal.ROUND_HALF_UP);
		}
		for(int i=0; i<saleSkuPos.size(); i++){
			if(i == saleSkuPos.size() - 1){
				BigDecimal remainPrice = packagePrice.subtract(salePriceTmp);
				saleSkuPos.get(i).setDiscountAmount(remainPrice);
			}else{
				//平摊价
				BigDecimal discountPrice = (new BigDecimal(saleSkuPos.get(i).getSalesPrice())).multiply(salePercent);
				saleSkuPos.get(i).setDiscountAmount(discountPrice);
				salePriceTmp = salePriceTmp.add(discountPrice);
			}
		}
	}

	@Override
	public List<SaleSkuPo> findPackageItemsBySkuId(SaleSkuPo saleSkuPo) {
		List<SaleSkuPo> itemSaleSkuPos = new ArrayList<SaleSkuPo>();
		if(saleSkuPo != null){
			List<SalePackageItemPo> salePackageItemPos = salePackageItemRepository.findBySkuId(saleSkuPo.getId());
			if(salePackageItemPos != null && salePackageItemPos.size() > 0){
				for(SalePackageItemPo salePackageItemPo : salePackageItemPos){
					//排除套餐自己
					if(salePackageItemPo.getSkuId().equals(salePackageItemPo.getItemSkuId())){
						continue;
					}
					SaleSku saleSku2  = this.load(salePackageItemPo.getItemSkuId());
					if(saleSku2 != null){
						if(StringUtils.isNotEmpty(saleSku2.getData().getAttrOpIds())){
							ProductMediaPo productMediaPo = productMediaRepository.getMainMediaPoByProdIdAttrOpId(saleSku2.getData().getSaleProdId(), saleSku2.getData().getAttrOpIds());
							saleSku2.getData().setProductMediaPo(productMediaPo);
							//获取产品媒体
							List<ProductMediaPo> productMediaPos = new ArrayList<ProductMediaPo>();
							if(productMediaPo!=null){
								productMediaPo.setSpecialValue("main");
								productMediaPos.add(productMediaPo);	
							}
							else{
								productMediaPo = new ProductMediaPo();
								productMediaPo.setSpecialValue("main");
								productMediaPos.add(productMediaPo);
							}
							//获取特殊尺寸
							List<ProductMediaPo> specialList = productMediaRepository.findSpecialMediaPoByProdIdAttrOpId(saleSku2.getData().getSaleProdId(), saleSku2.getData().getAttrOpIds());
							for(ProductMediaPo productMediaPo2:specialList){
								productMediaPos.add(productMediaPo2);
							}
							saleSku2.getData().setProductMediaPoList(productMediaPos);
							
						}else{
							List<ProductMediaPo> productMediaPos = new ArrayList<ProductMediaPo>();
							ProductMediaPo productMediaPo = productMediaRepository.getMainMediaPoByProdId(saleSku2.getData().getSaleProdId());
							if(productMediaPo!=null){
								saleSku2.getData().setProductMediaPo(productMediaPo);
								productMediaPo.setSpecialValue("main");
								productMediaPos.add(productMediaPo);
							} 
							else{
								productMediaPo = new ProductMediaPo();
								productMediaPo.setSpecialValue("main");
								productMediaPos.add(productMediaPo);
							}
							//获取特殊尺寸
							List<ProductMediaPo> specialList = productMediaRepository.findSpecialMediaPoByProdId(saleSku2.getData().getSaleProdId());
							for(ProductMediaPo productMediaPo2:specialList){
								productMediaPos.add(productMediaPo2);
							}
							saleSku2.getData().setProductMediaPoList(productMediaPos);
						}
						itemSaleSkuPos.add(saleSku2.getData());
					}
				}
			}
			handlePackagePrice(saleSkuPo, itemSaleSkuPos);
		}
		return itemSaleSkuPos;
	}
	
	@Override
	public List<SaleSkuPo> find2(Map<String, Object> params,Page page){
		return saleSkuQueryDao.find2(params,page);
	}	

	@Override
	public List<SaleSkuPo> findAll2(String prodId, String attrIds) {
		return saleSkuQueryDao.findAll2(prodId,attrIds);
	}

	@Override
	public Integer find2Count(Map<String, Object> params) {
		return saleSkuQueryDao.find2Count(params);
	}

	@Override
	public List<SaleSkuPo> findBuyAttrOpIds(String productId, String attrOpIds) {
		return saleSkuQueryDao.findBuyAttrOpIds(productId,attrOpIds);
	}

	@Override
	public SaleSkuPo findBySaleItemId(String prodSkuId) {
		Map<String, Object> params = new HashMap<>();
		params.put("prodSkuId", prodSkuId);
		return saleSkuQueryDao.getByKey("findBySaleItemId", params);
	}

	

}
